package com.atguigu.java2;

import com.atguigu.java1.Employee;
import com.atguigu.java1.EmployeeDate;
import org.junit.Test;

import java.util.Arrays;
import java.util.List;
import java.util.function.UnaryOperator;
import java.util.stream.IntStream;
import java.util.stream.Stream;

/**
 * 1.Stream 关注的是对数据的运算，与CPU打交道
 * 集合关注的是数据的存储，与内存打交道
 * <p>
 * 2、
 * ①：Stream自己不会存储数据
 * ②：不会改变原对象。相反，他们会返回一个持有结果的新Stream
 * ③：操作是延迟执行的，这意味着他们会等到需要结果的时候才执行
 * <p>
 * 3.Stream执行流程
 * ①：Stream的实例化
 * ②：一系列的中间操作（过滤，映射。。。）
 * ③：终止操作
 * <p>
 * 4.说明
 * 4.1：一个中间操作链，对数据源进行操作
 * 4.2：一旦执行终止操作，就执行中间操作链，并产生结果，之后，就不会再被使用
 * <p>
 * <p>
 * 测试StreamAPI的实例化
 *
 * @author shkstart
 * @create 2021-03-05 22:43
 */
public class StreamAPITest {

    //创建StreamAPI对象方式一：通过集合
    @Test
    public void test1() {
        List<Employee> list = EmployeeDate.getEmployees();
//        default Stream<E> stream;:返回一个顺序流
        Stream<Employee> stream = list.stream();

//        default Stream<E> parallelStream();：返回一个并行流

        Stream<Employee> employeeStream = list.parallelStream();

    }

    //创建Stream方式二：通过数组
    @Test
    public void test2() {

        //调用Arrays类的static<T> Stream<T> stream(T[] array):返回一个流
        int[] arr = new int[]{1, 2, 3, 4};
        IntStream stream = Arrays.stream(arr);

        //自定义数组类创建方式
        Employee employee = new Employee(1001, "小李", 12, 12);
        Employee employee1 = new Employee(1002, "小房", 14, 1141);
        Employee[] employees = new Employee[]{employee, employee1};
        Stream<Employee> stream1 = Arrays.stream(employees);

    }

    //创建Stream方式三：通过Stream的of()
    @Test
    public void test3() {

        Stream<Integer> integerStream = Stream.of(1, 2, 3, 4);


    }

    //创建Stream方式四：创建无限流
    @Test
    public void test4() {

        //迭代
//        public static<T> Stream<T> iterate(final T seed,final UnaryOperator<T> f)
        //遍历前十个偶数

        Stream.iterate(0, t -> t + 2).limit(10).forEach(System.out::println);

        Stream.iterate(0, new UnaryOperator<Integer>() {
            @Override
            public Integer apply(Integer integer) {
                return integer + 2;
            }
        }).limit(10).forEach(System.out::println);
        //生成
        //public static<T> Stream<T> generate(Supplier<T> s)
        Stream.generate(Math::random).limit(10).forEach(System.out::println);

    }

}
